package com.zkjd.lingdong.service.executor

import android.content.Context
import com.adayo.service.utils.CarPropertyUtils
import com.zkjd.lingdong.bluetooth.BleAuthUtils
import com.zkjd.lingdong.model.ButtonFunction
import com.zkjd.lingdong.model.ButtonType
import com.zkjd.lingdong.repository.DeviceEvent
import com.zkjd.lingdong.service.executor.MeiJiaCarFunctionExecutor.Companion
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import timber.log.Timber
import javax.inject.Inject
import javax.inject.Singleton

private const val TAG = "CarFunctionExecutor"

/**
 * 车辆功能执行器
 * 负责处理车辆控制相关功能，如空调、座椅、车门等控制
 */
@Singleton
class CarFunctionExecutor @Inject constructor(
    private val context: Context
) {

    /** 设备事件流 */
    private val deviceEventsFlow = MutableSharedFlow<DeviceEvent>(replay = 0)

    /**
     * 获取设备事件流
     * @return 设备事件共享流
     */
    fun getDeviceEvents(): SharedFlow<DeviceEvent> = deviceEventsFlow

    // Car属性工具类
    private val carPropertyUtils: CarPropertyUtils by lazy {
        CarPropertyUtils.getInstance().also {
            it.connectCar(context)
        }
    }
    
    // 车辆功能相关CAN信号ID常量
    companion object {
        // 后备箱控制
        private const val ID_TRUNK_CONTROL = 0x2940f038
        // 儿童锁控制
        private const val ID_CHILD_LOCK = 0x29404140
        // 方向盘加热
        private const val ID_STEERING_WHEEL_HEAT = 0x29403558
        // 座椅加热（主驾、副驾）
        private const val ID_SEAT_HEAT = 0x1540050B
        // 空调温度调节
        private const val ID_AC_TEMPERATURE = 0x15600503
        // 空调风量调节
        private const val ID_AC_FAN_SPEED_SET = 0x25401908
        private const val ID_AC_FAN_SPEED_GET = 0x15400514
        // 空调吹风方向
        private const val ID_AC_WIND_DIRECTION = 0x15400501
        // 驾驶模式
        private const val ID_DRIVING_MODE = 0x294034B7
        // 前后除霜除雾
        private const val ID_DEFROST = 0x13400504
        // 空调温度模式
        private const val ID_AC_ZONE_TEMP = 0x15400505
        // 空调内外循环
        private const val ID_AC_INNER_OUTER_CYCLE = 0x15400502

        //前排空调开关 关闭
        private const val ID_ZONED_HVAC_POWER_ON=0x35400101

        //主驾小憩模式
        private const val ID_HVAC_SCENE_MODE_ACT=0x31400526
        //副驾小憩模式
        private const val ID_RESPITE_MODE=0x7000024
        //后视镜开关
        private const val ID_BACK_MIRROR_SW=0x31400354
        //二排安全带未系报警提示音
        private const val ID_REAR_SEATBELT_WARNING_SW=0x3140034A
        //雨刮模式
        private const val ID_WIPER_ADJUST_MODE=0x31400355
        //低速行人报警音
        private const val ID_ACOUSTIC_VEH_ALERT=0x294034e5
        //座椅通风
        private const val ID_ZONED_HVAC_SEAT_VENTILATION=0x35400111
        //老板键 副驾座椅移动控制
        private const val ID_BODY_SEAT_STATUS=0x314005E0

    }
    
    /**
     * 执行车辆相关功能
     * @param function 要执行的功能
     * @param buttonType 触发的按键类型，用于处理旋转功能
     */
    suspend fun executeCarFunction(
        function: ButtonFunction,
        buttonType: ButtonType = ButtonType.SHORT_PRESS,
        macAddress: String
    ) {
        Timber.tag(TAG)
            .w("执行车辆功能: ${function.name}, 代码: ${function.actionCode}, 按键类型: $buttonType")
        
        // 处理旋转类功能
        if (function.useType==2 &&
           (buttonType == ButtonType.LEFT_ROTATE || buttonType == ButtonType.RIGHT_ROTATE)) {
            when (function.actionCode) {
                "CAR_AC_TEMPERATURE" -> {
                    // 空调温度调节
                    if (buttonType == ButtonType.RIGHT_ROTATE) {
                        // 顺时针旋转，增加温度
                        increaseACTemperature()
                    } else {
                        // 逆时针旋转，降低温度
                        decreaseACTemperature()
                    }
                    return
                }
                "CAR_AC_FAN_SPEED" -> {
                    // 空调风量调节
                    if (buttonType == ButtonType.RIGHT_ROTATE) {
                        // 顺时针旋转，增加风量
                        increaseFanSpeed()
                    } else {
                        // 逆时针旋转，降低风量
                        decreaseFanSpeed()
                    }
                    return
                }
            }
        }
        
        // 处理普通功能
        when (function.actionCode) {
            // 后备箱相关功能
            "CAR_TRUNK_TOGGLE" -> toggleTrunk()
            "CAR_TRUNK_CONTROL_TOGGLE" -> toggleTrunkControl()
            "CAR_TRUNK_POSITION" -> adjustTrunkPosition()
            
            // 车门相关功能
            "CAR_CHILD_LOCK_TOGGLE1" -> toggleChildLock1()
            "CAR_CHILD_LOCK_TOGGLE2" -> toggleChildLock2()
            "CAR_MAIN_SEAT_TOGGLE" -> toggleMainSeatDoor()
            "CAR_COPILOT_SEAT_TOGGLE" -> toggleCopilotSeatDoor()
            "CAR_LEFT_REAR_SEAT_TOGGLE" -> toggleLeftRearSeatDoor()
            "CAR_RIGHT_REAR_SEAT_TOGGLE" -> toggleRightRearSeatDoor()
            
            // 座椅相关功能
            "CAR_MAIN_SEAT_REST_TOGGLE" -> toggleMainSeatRest()
            "CAR_COPILOT_SEAT_REST_TOGGLE" -> toggleCopilotSeatRest()
            "CAR_MAIN_SEAT_HEAT_TOGGLE" -> toggleMainSeatHeat()
            "CAR_COPILOT_SEAT_HEAT_TOGGLE" -> toggleCopilotSeatHeat()
            "CAR_STEERING_WHEEL_HEAT_TOGGLE" -> toggleSteeringWheelHeat()
            
            // 按摩相关功能
            "CAR_LEFT_REAR_MASSAGE_TOGGLE" -> toggleLeftRearMassage()
            "CAR_RIGHT_REAR_MASSAGE_TOGGLE" -> toggleRightRearMassage()
            "CAR_MASSAGE_INTENSITY" -> adjustMassageIntensity()
            "CAR_MASSAGE_MODE" -> adjustMassageMode()
            
            // 通风相关功能
            "CAR_LEFT_REAR_VENT_TOGGLE" -> toggleLeftRearVent()
            "CAR_RIGHT_REAR_VENT_TOGGLE" -> toggleRightRearVent()
            
            // 冰箱相关功能
            "CAR_FRIDGE_TOGGLE" -> toggleFridge()
            "CAR_FRIDGE_COOLING" -> setFridgeCooling()
            "CAR_FRIDGE_HEATING" -> setFridgeHeating()
            "CAR_FRIDGE_TEMPERATURE" -> adjustFridgeTemperature()
            
            // 空调相关功能
            "CAR_AC_TEMPERATURE" -> adjustAcTemperature()
            "CAR_AC_FAN_SPEED" -> adjustAcFanSpeed()
            "CAR_AC_WIND_DIRECTION" -> adjustAcWindDirection()
            "CAR_DEFROST" -> toggleDefrost()
            "CAR_DEFROST2" -> toggleDefrost2()
            //空调开关
            "CAR_AIR_CONDITIONING" -> setAirCdFront()
            
            // 驾驶相关功能
            "CAR_DRIVING_MODE" -> adjustDrivingMode()
            "CAR_ENERGY_MANAGEMENT" -> adjustEnergyManagement()
            "CAR_CENTRAL_CONTROL" -> toggleCentralControl()
            
            // 灯光/相机相关功能
            "CAR_SMART_LIGHT_TOGGLE" -> toggleSmartLight()
            "CAR_CAMERA_PHOTO" -> takeCarCameraPhoto()
            "CAR_CAMERA_VIDEO" -> recordCarCameraVideo()
            
            // 屏幕相关功能
            "CAR_SCREEN_RESTART" -> restartCarScreen()
            "CAR_COPILOT_SCREEN_TOGGLE" -> adjustCopilotScreen()
            
            // 新增空调相关功能
            "CAR_AC_TOGGLE" -> toggleAC()
            "CAR_AC_TEMPERATURE_UP" -> increaseACTemperature()
            "CAR_AC_TEMPERATURE_DOWN" -> decreaseACTemperature()
            "CAR_FAN_SPEED_UP" -> increaseFanSpeed()
            "CAR_FAN_SPEED_DOWN" -> decreaseFanSpeed()
            "CAR_DEFROST_TOGGLE" -> toggleDefrost()
            "CAR_CIRCULATION_TOGGLE" -> toggleCirculation()
            "CAR_SEAT_HEAT_TOGGLE" -> toggleSeatHeat()
            "CAR_WINDOWS_TOGGLE" -> toggleWindows()
            "CAR_AUTO_MODE_TOGGLE" -> toggleAutoMode()
            
            // 新增空调温度模式相关功能
            "CAR_AC_ZONE_TEMP_TOGGLE" -> toggleAcZoneMode()
            "CAR_AC_AIR_CIRCULATION_TOGGLE" -> toggleAcAirCirculation()

            //主驾小憩模式
            "CAR_RESTING_MODE_LEFT" -> toggleMainSeatRest()
            //副驾小憩模式
            "CAR_RESTING_MODE_RIGHT" -> toggleCopilotSeatRest()
            //后视镜折叠
            "CAR_FOLDING_REARVIEW_MIRROR" -> toRearViewMirrorFold()
            //二排安全带未系报警提示音
            "CAR_SEAT_BELT_NOTFASTENED" -> toSeatBeltCheck()
            //雨刮模式
            "CAR_WIPER_MODE" -> toWiper()

            //老板键
            "CAR_BOSS_KEY" -> toHorizontalPositionSts()

            //主驾座椅通风开/关
            "CAR_LEFT_REAR_VENT_TOGGLE" -> toSeatVentilationLeft()

            //副驾座椅通风开/关
            "CAR_RIGHT_REAR_VENT_TOGGLE" -> toSeatVentilationRight()


            //低速行人报警音
            "CAR_LOW_SPEED_PEDESTRIAN" -> toLowSpeedPedestrianAlarm()
            else -> {
                Timber.tag(TAG).w("未知车辆功能代码: ${function.actionCode}")
            }
        }
    }

    /**
     * 空调开关
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x35400101 (ID_ZONED_HVAC_POWER_ON)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *   0x1=关闭
     *   0x2=开启
     */
    private suspend fun setAirCdFront() {
        Timber.tag(TAG).w("空调开关状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_ZONED_HVAC_POWER_ON, 1)
            Timber.tag(TAG).w("空调开关状态: $currentState")

            // 切换状态 (1→2, 2→1, 其他→2)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前关闭，则开启
                0x2 -> 0x1 // 如果当前开启，则关闭
                else -> 0x2 // 其他状态（未知等）则默认开启
            }

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_TRUNK_CONTROL, 1, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "空调${if (newState == 0x2) "开启" else "关闭"}"))

            Timber.tag(TAG).w("设置空调状态为: ${if (newState == 0x2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换空调状态失败")
        }
    }

    /**
     * 切换后备箱开关状态
     * 使用CarPropertyUtils设置后备箱开关状态
     * 
     * ID: 0x2940f038 (ID_TRUNK_CONTROL)
     * 区域: 0x05
     * 值类型: int
     * 值说明: 
     *   0x1=关闭
     *   0x2=开启
     */
    private suspend fun toggleTrunk() {
        Timber.tag(TAG).w("切换后备箱开关状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_TRUNK_CONTROL, 0x05)
            Timber.tag(TAG).w("当前后备箱状态: $currentState")
            
            // 切换状态 (1→2, 2→1, 其他→2)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前关闭，则开启
                0x2 -> 0x1 // 如果当前开启，则关闭
                else -> 0x2 // 其他状态（未知等）则默认开启
            }
            
            // 设置新状态
            carPropertyUtils.setIntProperty(ID_TRUNK_CONTROL, 0x05, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "后备箱${if (newState == 0x2) "开启" else "关闭"}"))

            Timber.tag(TAG).w("设置后备箱状态为: ${if (newState == 0x2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换后备箱状态失败")
        }
    }
    
    /**
     * 切换儿童锁开关状态
     * 使用CarPropertyUtils设置儿童锁状态
     * 
     * ID: 0x29404140 (ID_CHILD_LOCK)
     * 区域: 0x0
     * 值类型: int
     * 值说明:
     *   0x0=无效
     *   0x1=开启
     *   0x2=关闭
     *   0x3=保留
     */
    private suspend fun toggleChildLock1() {
        Timber.tag(TAG).w("切换左儿童锁开关状态")
        try {
            // 获取当前儿童锁状态
            val currentState = carPropertyUtils.getIntStatus(ID_CHILD_LOCK, 0x1)
            Timber.tag(TAG).w("当前左儿童锁状态: $currentState")
            
            // 切换状态 (1→2, 2→1, 其他→1)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前开启，则关闭
                0x2 -> 0x1 // 如果当前关闭，则开启
                else -> 0x1 // 其他状态（未知、无效等）则默认开启
            }
            
            // 设置新状态
            carPropertyUtils.setIntProperty(ID_CHILD_LOCK, 0x3, newState)
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "左儿童锁${if (newState == 0x1) "开启" else "关闭"}"))
            Timber.tag(TAG).w("设置左儿童锁状态为: ${if (newState == 0x1) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换左儿童锁状态失败")
        }
    }

    /**
     * 切换儿童锁开关状态
     * 使用CarPropertyUtils设置儿童锁状态
     *
     * ID: 0x29404140 (ID_CHILD_LOCK)
     * 区域: 0x0
     * 值类型: int
     * 值说明:
     *   0x0=无效
     *   0x1=开启
     *   0x2=关闭
     *   0x3=保留
     */
    private suspend fun toggleChildLock2() {
        Timber.tag(TAG).w("切换右儿童锁开关状态")
        try {
            // 获取当前儿童锁状态
            val currentState = carPropertyUtils.getIntStatus(ID_CHILD_LOCK, 0x2)
            Timber.tag(TAG).w("当前右儿童锁状态: $currentState")

            // 切换状态 (1→2, 2→1, 其他→1)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前开启，则关闭
                0x2 -> 0x1 // 如果当前关闭，则开启
                else -> 0x1 // 其他状态（未知、无效等）则默认开启
            }

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_CHILD_LOCK, 0x4, newState)
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "右儿童锁${if (newState == 0x1) "开启" else "关闭"}"))
            Timber.tag(TAG).w("设置右儿童锁状态为: ${if (newState == 0x1) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换右儿童锁状态失败")
        }
    }


    /**
     * 后视镜
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x31400354 (ID_BACK_MIRROR_SW)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *   0x1=fold
     *   0x2=unfold
     */
    private suspend fun toRearViewMirrorFold() {
        Timber.tag(TAG).w("后视镜开关状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_BACK_MIRROR_SW, 0)
            Timber.tag(TAG).w("后视镜开关状态: $currentState")

            // 切换状态 (1→2, 2→1, 其他→2)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前关闭，则开启
                0x2 -> 0x1 // 如果当前开启，则关闭
                else -> 0x2 // 其他状态（未知等）则默认开启
            }

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_BACK_MIRROR_SW, 0, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "后视镜${if (newState == 0x2) "开启" else "关闭"}"))

            Timber.tag(TAG).w("设置后视镜开关状态: ${if (newState == 0x2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换后视镜开关状态失败")
        }
    }


    /**
     * 二排安全带未系报警提示音
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x31400354 (ID_REAR_SEATBELT_WARNING_SW)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *   0x1=off
     *   0x2=on
     */
    private suspend fun toSeatBeltCheck() {
        Timber.tag(TAG).w("二排安全带未系报警提示音开关状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_REAR_SEATBELT_WARNING_SW, 0)
            Timber.tag(TAG).w("二排安全带未系报警提示音开关状态: $currentState")

            // 切换状态 (1→2, 2→1, 其他→2)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前关闭，则开启
                0x2 -> 0x1 // 如果当前开启，则关闭
                else -> 0x2 // 其他状态（未知等）则默认开启
            }

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_REAR_SEATBELT_WARNING_SW, 0, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "二排安全带未系报警提示音${if (newState == 0x2) "开启" else "关闭"}"))

            Timber.tag(TAG).w("设置二排安全带未系报警提示音开关状态: ${if (newState == 0x2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换后二排安全带未系报警提示音开关状态失败")
        }
    }

    /**
     * 雨刮器模式
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x31400354 (ID_REAR_SEATBELT_WARNING_SW)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *   0x1=off
     *   0x2=on
     */
    private suspend fun toWiper() {
        Timber.tag(TAG).w("雨刮器模式开关状态")
        try {
            // 获取当前后备箱状态
            val currentStateFront = carPropertyUtils.getIntStatus(ID_WIPER_ADJUST_MODE, 1) //前
//            val currentStateAfter = carPropertyUtils.getIntStatus(ID_WIPER_ADJUST_MODE, 2) //后
            Timber.tag(TAG).w("雨刮器模式开关状态: 前面$currentStateFront ")

            // 切换状态 (1→2, 2→1, 其他→2)
            val newState = when (currentStateFront) {
                0x0 -> 0x1
                0x1 -> 0x2 // 如果当前关闭，则开启
                0x2 -> 0x3
                0x3 -> 0x0// 如果当前开启，则关闭
                else -> 0x1 // 其他状态（未知等）则默认开启
            }

            // 输出设置后的吹风方向
            val modeDesc = when (newState) {
                0x1 -> "低速"
                0x2 -> "高速"
                0x3 -> "AOTU"
                else -> "关闭"
            }

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_WIPER_ADJUST_MODE, 1, newState)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "雨刮器模式 $modeDesc"))

            Timber.tag(TAG).w("雨刮器模式开关状态: $newState")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切雨刮器模式开关状态失败")
        }
    }

    /**
     * 老板键
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x314005E0 (ID_BODY_SEAT_STATUS)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *   1~101=0%~100%
     */
    private suspend fun toHorizontalPositionSts () {
        Timber.tag(TAG).w("老板键状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_BODY_SEAT_STATUS, 0)
            Timber.tag(TAG).w("老板键状态: $currentState")

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_BODY_SEAT_STATUS, 0, currentState+10)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "老板键 $currentState+10"))

            Timber.tag(TAG).w("老板键状态: $currentState+10")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "老板键状态失败")
        }
    }

    /**
     * 主驾通风
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x35400111 (ID_ZONED_HVAC_SEAT_VENTILATION)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *  0 off
     *  1-3  leve1-3
     */
    private suspend fun toSeatVentilationLeft () {
        Timber.tag(TAG).w("主驾通风状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_ZONED_HVAC_SEAT_VENTILATION, 1)
            Timber.tag(TAG).w("主驾通风状态: $currentState")

            // 循环切换档位 (0→1→2→3→0)
            val newLevel = (currentState + 1) % 4

            val nameStirng = when (newLevel) {
                0 -> "关闭"  // 舒适→运动
                1 -> "Level 1"  // 运动→经济
                2 -> "Level 2"  // 经济→专属
                3 -> "Level 3"  // 专属→自定义
                else -> "关闭" // 其他→舒适
            }
            // 设置新状态
            carPropertyUtils.setIntProperty(ID_ZONED_HVAC_SEAT_VENTILATION, 1, newLevel)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "主驾座椅通风 $nameStirng"))

            Timber.tag(TAG).w("主驾通风开关已设置为: $currentState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "主驾通风开关设置失败")
        }
    }

    /**
     * 副驾通风
     * 使用CarPropertyUtils设置后备箱开关状态
     *
     * ID: 0x35400111 (ID_ZONED_HVAC_SEAT_VENTILATION)
     * 区域: 0x05
     * 值类型: int
     * 值说明:
     *  0 off
     *  1-3  leve1-3
     */
    private suspend fun toSeatVentilationRight () {
        Timber.tag(TAG).w("副驾通风状态")
        try {
            // 获取当前后备箱状态
            val currentState = carPropertyUtils.getIntStatus(ID_ZONED_HVAC_SEAT_VENTILATION, 4)
            Timber.tag(TAG).w("副驾通风状态: $currentState")

            // 循环切换档位 (0→1→2→3→0)
            val newLevel = (currentState + 1) % 4

            val nameStirng = when (newLevel) {
                0 -> "关闭"  // 舒适→运动
                1 -> "Level 1"  // 运动→经济
                2 -> "Level 2"  // 经济→专属
                3 -> "Level 3"  // 专属→自定义
                else -> "关闭" // 其他→舒适
            }
            // 设置新状态
            carPropertyUtils.setIntProperty(ID_ZONED_HVAC_SEAT_VENTILATION, 1, newLevel)

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "副驾座椅通风 $nameStirng"))

            Timber.tag(TAG).w("副驾通风开关已设置为: $currentState")

        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "副驾通风开关设置失败")
        }
    }

    /**
     * 低速行人报警音
     * ID: 0x294034e5 (ID_ACOUSTIC_VEH_ALERT)
     * 值类型: int
     */
    suspend fun toLowSpeedPedestrianAlarm(){
        Timber.tag(TAG).w("低速行人报警音开关")
        try {

            val currentState = carPropertyUtils.getIntStatus(ID_ACOUSTIC_VEH_ALERT,3)
            Timber.tag(TAG).w("低速行人报警音开关状态: $currentState")

            // 切换状态 (1→0, 0→1)
            val newState = when (currentState) {
                0 -> 1 // 如果当前关闭，则开启
                1 -> 0 // 如果当前非关闭状态，则关闭
                else -> 1
            }

            carPropertyUtils.setIntProperty(ID_ACOUSTIC_VEH_ALERT,3, newState)

            //deviceEventsFlow.emit(DeviceEvent.SetFunction("", "低速行人报警音 ${if (newState == 0) "关闭" else "开启"}"))
            Timber.tag(TAG).w("低速行人报警音开关已设置为: $currentState")

//            val currentState=carPropertyUtils.getFBaseStatus(CarPropertyUtils.ID_CAR_TYPE,0)
//
//
//
//            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "配置字：${BleAuthUtils.byteArrayToHexString(currentState)}"))
//            Timber.tag(TAG).w("配置测试: ${BleAuthUtils.byteArrayToHexString(currentState)}")


        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "低速行人报警音开关设置失败")
        }
    }


    /**
     * 切换方向盘加热开关状态
     * 使用CarPropertyUtils设置方向盘加热状态
     * 
     * ID: 0x29403558 (ID_STEERING_WHEEL_HEAT)
     * 区域: 0x0
     * 值类型: int
     * 值说明:
     *   0x0=无效
     *   0x1=关闭
     *   0x2=开启
     *   0x3=保留
     */
    private fun toggleSteeringWheelHeat() {
        Timber.tag(TAG).w("切换方向盘加热开关状态")
        try {
            // 获取当前方向盘加热状态
            val currentState = carPropertyUtils.getIntStatus(ID_STEERING_WHEEL_HEAT, 0x0)
            Timber.tag(TAG).w("当前方向盘加热状态: $currentState")
            
            // 切换状态 (1→2, 2→1, 其他→2)
            val newState = when (currentState) {
                0x1 -> 0x2 // 如果当前关闭，则开启
                0x2 -> 0x1 // 如果当前开启，则关闭
                else -> 0x2 // 其他状态（未知、无效等）则默认开启
            }
            
            // 设置新状态
            carPropertyUtils.setIntProperty(ID_STEERING_WHEEL_HEAT, 0x0, newState)
            Timber.tag(TAG).w("设置方向盘加热状态为: ${if (newState == 0x2) "开启" else "关闭"}")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换方向盘加热状态失败")
        }
    }
    
    /**
     * 切换主驾车门开关状态
     */
    private fun toggleMainSeatDoor() {
        Timber.tag(TAG).w("切换主驾车门开关状态")
    }
    
    /**
     * 切换副驾车门开关状态
     */
    private fun toggleCopilotSeatDoor() {
        Timber.tag(TAG).w("切换副驾车门开关状态")
    }
    
    /**
     * 切换二排左车门开关状态
     */
    private fun toggleLeftRearSeatDoor() {
        Timber.tag(TAG).w("切换二排左车门开关状态")
        // TODO: 实现二排左车门开关控制逻辑
    }
    
    /**
     * 切换二排右车门开关状态
     */
    private fun toggleRightRearSeatDoor() {
        Timber.tag(TAG).w("切换二排右车门开关状态")
        // TODO: 实现二排右车门开关控制逻辑
    }
    
    /**
     * 切换主驾休息模式开关状态
     *  * ID: 0x29403558 (ID_HVAC_SCENE_MODE_ACT)
     *      * 区域: 0x0
     *      * 值类型: int
     *      * 值说明:
     *      0x0=No Req;
     *      0x1=静心减压;
     *      0x2=清新提神:
     *      0x3=夜色柔情:
     *      0x4=悠然惬意;
     *      0x5=我心狂野:
     *      0x6=童趣空降;
     *      0x7=宝贝安抚:
     *      0x8=休憩模式(含休憩、冥想、神游)
     *      0x9=露营模式:
     *      0xA=宠物模式:
     */
    private fun toggleMainSeatRest() {
        Timber.tag(TAG).w("切换主驾休息模式开关状态")
        try {
            // 获取切换主驾休息模式开关状态
            val currentMode = carPropertyUtils.getIntStatus(ID_HVAC_SCENE_MODE_ACT, 0)
            Timber.tag(TAG).w("切换主驾休息模式开关状态: $currentMode")

            // 循环运动模式: 舒适->运动->经济->专属->自定义->舒适
            val newMode = when (currentMode) {
                0x0 -> 0x1  //舒适->运动
                0x1 -> 0x2  //运动->经济
                0x2 -> 0x3  //经济->专属
                0x3 -> 0x4
                0x4 -> 0x5  //专属->自定义
                0x5 -> 0x6  //自定义->舒适
                0x6 -> 0x7  //自定义->舒适
                0x7 -> 0x8  //自定义->舒适
                0x8 -> 0x9  //自定义->舒适
                0x9 -> 0xA  //自定义->舒适
                0xA -> 0x0  //自定义->舒适
                else -> 0x1 //其他→舒适
            }

            // 设置新的驾驶模式
            carPropertyUtils.setIntProperty(ID_HVAC_SCENE_MODE_ACT, 0, newMode)

            // 输出设置后的吹风方向
            val modeDesc = when (newMode) {
                0x1 -> "静心减压"
                0x2 -> "清新提神"
                0x3 -> "夜色柔情"
                0x4 -> "悠然惬意"
                0x5 -> "我心狂野"
                0x6 -> "童趣空降"
                0x7 -> "宝贝安抚"
                0x8 -> "休憩模式"
                0x9 -> "露营模式"
                0xA -> "宠物模式"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置主驾休息模式: $modeDesc ($newMode)")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节主驾休息模式失败")
        }
    }

    /**
     * 切换副驾休息模式开关状态
     *  * ID: 0x29403558 (ID_HVAC_SCENE_MODE_ACT)
     *      * 区域: 0x0
     *      * 值类型: int
     *      * 值说明:
     *      0x0=No Req;
     *      0x1=静心减压;
     *      0x2=清新提神:
     *      0x3=夜色柔情:
     *      0x4=悠然惬意;
     *      0x5=我心狂野:
     *      0x6=童趣空降;
     *      0x7=宝贝安抚:
     *      0x8=休憩模式(含休憩、冥想、神游)
     *      0x9=露营模式:
     *      0xA=宠物模式:
     */
    private fun toggleCopilotSeatRest() {
        Timber.tag(TAG).w("切换副驾休息模式开关状态")
        try {
            // 获取切换主驾休息模式开关状态
            val currentMode = carPropertyUtils.getIntStatus(ID_HVAC_SCENE_MODE_ACT, 0)
            Timber.tag(TAG).w("切换副驾休息模式开关状态: $currentMode")

            // 循环运动模式: 舒适->运动->经济->专属->自定义->舒适
            val newMode = when (currentMode) {
                0x0 -> 0x1  //舒适->运动
                0x1 -> 0x2  //运动->经济
                0x2 -> 0x3  //经济->专属
                0x3 -> 0x4
                0x4 -> 0x5  //专属->自定义
                0x5 -> 0x6  //自定义->舒适
                0x6 -> 0x7  //自定义->舒适
                0x7 -> 0x8  //自定义->舒适
                0x8 -> 0x9  //自定义->舒适
                0x9 -> 0xA  //自定义->舒适
                0xA -> 0x0  //自定义->舒适
                else -> 0x1 //其他→舒适
            }

            // 设置新的驾驶模式
            carPropertyUtils.setIntProperty(ID_HVAC_SCENE_MODE_ACT, 0, newMode)

            // 输出设置后的吹风方向
            val modeDesc = when (newMode) {
                0x1 -> "静心减压"
                0x2 -> "清新提神"
                0x3 -> "夜色柔情"
                0x4 -> "悠然惬意"
                0x5 -> "我心狂野"
                0x6 -> "童趣空降"
                0x7 -> "宝贝安抚"
                0x8 -> "休憩模式"
                0x9 -> "露营模式"
                0xA -> "宠物模式"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置副驾小憩模式: $modeDesc ($newMode)")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节副驾小憩模式失败")
        }
    }


    
    /**
     * 设置主驾座椅加热
     * 使用CarPropertyUtils设置主驾座椅加热状态
     * 
     * ID: 0x1540050B (ID_SEAT_HEAT)
     * 区域: 0x1 (主驾)
     * 值类型: int
     * 值说明:
     *   0=关闭
     *   1~n=加热等级(暂时设置为1-3）
     */
    private fun toggleMainSeatHeat() {
        Timber.tag(TAG).w("设置主驾座椅加热")
        try {
            // 获取当前主驾座椅加热状态
            val currentLevel = carPropertyUtils.getIntStatus(ID_SEAT_HEAT, 0x1)
            Timber.tag(TAG).w("当前主驾座椅加热等级: $currentLevel")
            
            // 切换状态 (0→1, >0→0)
            val newLevel = (currentLevel+1) % 4

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_SEAT_HEAT, 0x1, newLevel)
            Timber.tag(TAG).w("设置主驾座椅加热为: $newLevel")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "设置主驾座椅加热失败")
        }
    }
    
    /**
     * 切换副驾座椅加热开关状态
     * 使用CarPropertyUtils设置副驾座椅加热状态
     * 
     * ID: 0x1540050B (ID_SEAT_HEAT)
     * 区域: 0x4 (副驾)
     * 值类型: int
     * 值说明:
     *   0=关闭
     *   1~n=加热等级(暂时设置为1-3）
     */
    private fun toggleCopilotSeatHeat() {
        Timber.tag(TAG).w("设置副驾座椅加热")
        try {
            // 获取当前主驾座椅加热状态
            val currentLevel = carPropertyUtils.getIntStatus(ID_SEAT_HEAT, 0x4)
            Timber.tag(TAG).w("当前副驾座椅加热等级: $currentLevel")

            // 切换状态 (0→1, >0→0)
            val newLevel = (currentLevel+1) % 4

            // 设置新状态
            carPropertyUtils.setIntProperty(ID_SEAT_HEAT, 0x4, newLevel)
            Timber.tag(TAG).w("设置副驾座椅加热为: $newLevel")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "设置副驾座椅加热失败")
        }
    }
    
    /**
     * 切换二排左按摩开关状态
     */
    private fun toggleLeftRearMassage() {
        Timber.tag(TAG).w("切换二排左按摩开关状态")
        // TODO: 实现二排左按摩开关控制逻辑
    }
    
    /**
     * 切换二排右按摩开关状态
     */
    private fun toggleRightRearMassage() {
        Timber.tag(TAG).w("切换二排右按摩开关状态")
        // TODO: 实现二排右按摩开关控制逻辑
    }
    
    /**
     * 切换二排左通风开关状态
     */
    private fun toggleLeftRearVent() {
        Timber.tag(TAG).w("切换二排左通风开关状态")
        // TODO: 实现二排左通风开关控制逻辑
    }
    
    /**
     * 切换二排右通风开关状态
     */
    private fun toggleRightRearVent() {
        Timber.tag(TAG).w("切换二排右通风开关状态")
        // TODO: 实现二排右通风开关控制逻辑
    }
    
    /**
     * 切换冰箱开关状态
     */
    private fun toggleFridge() {
        Timber.tag(TAG).w("切换冰箱开关状态")
        // TODO: 实现冰箱开关控制逻辑
    }
    
    /**
     * 设置冰箱制冷模式
     */
    private fun setFridgeCooling() {
        Timber.tag(TAG).w("设置冰箱制冷模式")
        // TODO: 实现冰箱制冷模式设置逻辑
    }
    
    /**
     * 设置冰箱制热模式
     */
    private fun setFridgeHeating() {
        Timber.tag(TAG).w("设置冰箱制热模式")
        // TODO: 实现冰箱制热模式设置逻辑
    }
    
    /**
     * 切换尾厢控制开关状态
     */
    private fun toggleTrunkControl() {
        Timber.tag(TAG).w("切换尾厢控制开关状态")
        // TODO: 实现尾厢控制开关状态控制逻辑
    }
    
    /**
     * 切换智慧大灯隐藏控制开关状态
     */
    private fun toggleSmartLight() {
        Timber.tag(TAG).w("切换智慧大灯隐藏控制开关状态")
        // TODO: 实现智慧大灯隐藏控制开关状态控制逻辑
    }
    
    /**
     * 使用车载云台相机拍照
     */
    private fun takeCarCameraPhoto() {
        Timber.tag(TAG).w("使用车载云台相机拍照")
        // TODO: 实现车载云台相机拍照逻辑
    }

    /**
     * 使用车载云台相机录像
     */
    private fun recordCarCameraVideo() {
        Timber.tag(TAG).w("使用车载云台相机录像")
        // TODO: 实现车载云台相机录像逻辑
    }
    
    /**
     * 重启车机屏幕
     */
    private fun restartCarScreen() {
        Timber.tag(TAG).w("重启车机屏幕")
        // TODO: 实现重启车机屏幕逻辑
    }
    
    /**
     * 调节空调温度
     */
    private fun adjustAcTemperature() {
        Timber.tag(TAG).w("调节空调温度")
        // TODO: 实现空调温度调节逻辑
    }
    
    /**
     * 调节空调风量
     */
    private fun adjustAcFanSpeed() {
        Timber.tag(TAG).w("调节空调风量")
        // TODO: 实现空调风量调节逻辑
    }
    
    /**
     * 调节空调吹风方向
     * 
     * ID: 0x15400501 (ID_AC_WIND_DIRECTION)
     * 区域: 0xF
     * 值类型: int
     * 值说明:
     *   0x8=点击吹脸区域
     *   0x9=点击吹脚区域
     *   0xa=点击除霜区域
     *   
     * @return 新设置的吹风方向描述
     */
    fun adjustAcWindDirection(): String {
        Timber.tag(TAG).w("调节空调吹风方向")
        try {
            // 获取当前吹风方向
            val currentDirection = carPropertyUtils.getIntStatus(ID_AC_WIND_DIRECTION, 0xF)
            Timber.tag(TAG).w("当前吹风方向: $currentDirection")
            
            // 循环切换吹风方向: 吹脸→吹脚→除霜→吹脸
            val newDirection = when (currentDirection) {
                0x8 -> 0x9  // 吹脸→吹脚
                0x9 -> 0xa  // 吹脚→除霜
                else -> 0x8 // 其他→吹脸
            }
            
            // 设置新的吹风方向
            carPropertyUtils.setIntProperty(ID_AC_WIND_DIRECTION, 0xF, newDirection)
            
            // 输出设置后的吹风方向
            val directionDesc = when (newDirection) {
                0x8 -> "吹脸"
                0x9 -> "吹脚"
                0xa -> "除霜"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置吹风方向为: $directionDesc ($newDirection)")
            return directionDesc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节空调吹风方向失败")
            return "操作失败"
        }
    }
    
    /**
     * 切换驾驶模式
     * 舒适/运动/经济/专属/自定义
     * 0x0=Inactive；
     * 0x1=ECO； 经济
     * 0x2=normal； 舒适
     * 0x3=sport；运动
     * 0x4=自定义
     * 1；0x5=自定义
     * 2；0x6=自定义
     * 3；0x7=Reserved
     */
    private fun adjustDrivingMode() :String{
        Timber.tag(TAG).w("切换驾驶模式")
        try {
            // 获取当前驾驶模式
            val currentMode = carPropertyUtils.getIntStatus(ID_DRIVING_MODE, 0x1)
            Timber.tag(TAG).w("切换驾驶模式: $currentMode")

            // 循环运动模式: 舒适->运动->经济->专属->自定义->舒适
            val newMode = when (currentMode) {
                0x0 -> 0x1  //舒适->运动
                0x1 -> 0x2  //运动->经济
                0x2 -> 0x3  //经济->专属
                0x3->0x4
                0x4 -> 0x5  //专属->自定义
                0x5 -> 0x1  //自定义->舒适
                else -> 0x1 //其他→舒适
            }

            // 设置新的驾驶模式
            carPropertyUtils.setIntProperty(ID_DRIVING_MODE, 0x1, newMode)

            // 输出设置后的吹风方向
            val modeDesc = when (newMode) {
                0x1 -> "经济"
                0x2 -> "舒适"
                0x3 -> "运动"
                0x4 -> "专属"
                0x5 -> "自定义"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置驾驶模式: $modeDesc ($newMode)")
            return modeDesc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节驾驶模式失败")
            return "操作失败"
        }
    }
    
    /**
     * 切换能量管理模式
     * 0x0=reserved；0x1=智能模式；0x2=市区模式；0x3=高速模式；0x4=应急模式；0x5=驻车充电模式；0x6~0x7=reserved
     * 设置：0x5
     * 设置：0x4
     * 设置：HU_REEVDrvMod
     * 获取：PCU_REEVDrvMod
     */
    private suspend fun adjustEnergyManagement():String {
        Timber.tag(TAG).w("切换能量管理模式")
        try {
            // 获取当前驾驶模式
            val currentMode = carPropertyUtils.getIntStatus(ID_DRIVING_MODE, 0x4)
            Timber.tag(TAG).w("切换能量管理模式: $currentMode")

            // 循环能量管理模式: 智能->市区->高速->应急->驻车->智能
            val newMode = when (currentMode) {
                0x1 -> 0x2  //智能->市区
                0x2 -> 0x3  //市区->高速
                0x3 -> 0x6  //高速->应急
                0x6 -> 0x2
                else -> 0x2 //其他→智能
            }

            // 设置新的能量管理模式
            carPropertyUtils.setIntProperty(ID_DRIVING_MODE, 0x5, newMode)

            // 输出设置后的能量管理模式
            val modeDesc = when (newMode) {
                0x1 -> "智能模式"
                0x2 -> "市区模式"
                0x3 -> "高速模式"
                0x4 -> "应急模式"
                0x5 -> "驻车充电"
                0x6 -> "山地模式"
                else -> "未知"
            }
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", modeDesc))

            Timber.tag(TAG).w("设置能量管理模式: $modeDesc ($newMode)")
            return modeDesc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节能量管理模式失败")
            return "操作失败"
        }
    }
    
    /**
     * 切换除雾除霜状态
     * 前后除霜除雾
     * ID_DEFROST = 0x13400504
     * 前除霜：0x1
     * 后除霜：0x2
     * 关闭：OFF = 0x01,
     * 开启：ON = 0x02,
     * 循环模式为前开->后开->前关->后关->前开
     */
    private fun toggleDefrost() :String {
        Timber.tag(TAG).w("切换除雾除霜状态")
        try {
            // 获取当前除雾除霜状态
            val currentMode1 = carPropertyUtils.getIntStatus(ID_DEFROST, 0x1)
            val currentMode2 = carPropertyUtils.getIntStatus(ID_DEFROST, 0x2)
            Timber.tag(TAG).w("切换除雾除霜状态: 前：$currentMode1，后：$currentMode2")

            val currentMode = (currentMode1 shl 0x4) + currentMode2

            // 循环除雾除霜模式: 前开->后开->前关->后关->前开
            val newMode = when (currentMode) {
                0x11 -> 0x21  //前关后关->前开后关
                0x21 -> 0x22  //前开后关->前开后开
                0x22 -> 0x12  //前开后开->前关后开
                0x12 -> 0x11  //前关后开->前关后关
                else -> 0x11 //其他→前关后关
            }

            val newMode1 = (newMode shr 0x4) and 0x0F
            val newMode2 = newMode and 0x0F

            // 设置新的除雾除霜模式
            carPropertyUtils.setIntProperty(ID_DEFROST, 0x1, newMode1)
            carPropertyUtils.setIntProperty(ID_DEFROST, 0x2, newMode2)

            // 输出设置后的除雾除霜模式
            val mode1Desc = when (newMode1) {
                0x1 -> "前关"
                0x2 -> "前开"
                else -> "未知"
            }
            val mode2Desc = when (newMode2) {
                0x1 -> "后关"
                0x2 -> "后开"
                else -> "未知"
            }
            Timber.tag(TAG).w("设置除雾除霜模式: $mode1Desc ($newMode1)，$mode2Desc ($newMode2)")
            return mode1Desc + mode2Desc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节除雾除霜模式失败")
            return "操作失败"
        }
    }

    /**
     * 切换除雾除霜状态
     * 前后除霜除雾
     * ID_DEFROST = 0x13400504
     * 前除霜：0x1
     * 后除霜：0x2
     * 关闭：OFF = 0x01,
     * 开启：ON = 0x02,
     * 循环模式为前开->后开->前关->后关->前开
     */
    private suspend fun toggleDefrost2() :String {
        Timber.tag(TAG).w("切换后除雾除霜状态")
        try {
            // 获取当前除雾除霜状态

            val currentMode2 = carPropertyUtils.getIntStatus(ID_DEFROST, 0x2)
            Timber.tag(TAG).w("切换后除雾除霜状态: $currentMode2")


            // 循环除雾除霜模式: 前开->后开->前关->后关->前开
            val newMode = when (currentMode2) {
                0x01 -> 0x02  //前关后关->前开后关
                0x02 -> 0x01  //前开后关->前开后开
                else -> 0x02 //其他→前关后关
            }

            carPropertyUtils.setIntProperty(ID_DEFROST, 0x2, newMode)

            // 输出设置后的除雾除霜模式
            val mode1Desc = when (newMode) {
                0x1 -> "关闭"
                0x2 -> "开启"
                else -> "未知"
            }

            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "CAR后除雾除霜 读取$currentMode2，设置$newMode"))

            Timber.tag(TAG).w("设置后除雾除霜模式: $mode1Desc ($newMode)")
            return mode1Desc
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "调节后除雾除霜模式失败")
            return "操作失败"
        }
    }
    
    /**
     * 切换中央控制状态
     */
    private fun toggleCentralControl() {
        Timber.tag(TAG).w("切换中央控制状态")
        // TODO: 实现中央控制状态切换逻辑
    }
    
    /**
     * 调节冰箱温度
     */
    private fun adjustFridgeTemperature() {
        Timber.tag(TAG).w("调节冰箱温度")
        // TODO: 实现冰箱温度调节逻辑
    }
    
    /**
     * 调节按摩强度
     */
    private fun adjustMassageIntensity() {
        Timber.tag(TAG).w("调节按摩强度")
        // TODO: 实现按摩强度调节逻辑
    }
    
    /**
     * 调整按摩模式
     */
    private fun adjustMassageMode() {
        Timber.tag(TAG).w("调整按摩模式")
        // TODO: 实现按摩模式调整逻辑
    }
    
    /**
     * 调节尾厢位置
     */
    private fun adjustTrunkPosition() {
        Timber.tag(TAG).w("调节尾厢位置")
        // TODO: 实现尾厢位置调节逻辑
    }
    
    /**
     * 调节副驾屏幕开度
     */
    private fun adjustCopilotScreen() {
        Timber.tag(TAG).w("调节副驾屏幕开度")
        // TODO: 实现副驾屏幕开度调节逻辑
    }
    
    // 空调温度范围
    private var currentAcTemperature = 25 // 默认温度
    private val minTemperature = 17 // 对应原始值0x01 (LO)
    private val maxTemperature = 33 // 对应原始值0x1F (HI)
    
    // 空调风量范围
    private var currentFanSpeed = 3 // 默认风量
    private val minFanSpeed = 1
    private val maxFanSpeed = 7
    
    /**
     * 切换空调开关状态
     */
    private fun toggleAC() {
        Timber.tag(TAG).w("切换空调开关状态")
        // TODO: 实现空调开关状态切换逻辑
    }
    
    /**
     * 提高空调温度
     * 
     * ID: 0x15600503 (ID_AC_TEMPERATURE)
     * 区域: 0x1
     * 值类型: int
     * 值说明: 
     *   0x01=LO (17.5℃)
     *   0x02-0x1E=18~32℃
     *   0x1F=HI (32.5℃)
     *   0x30=温度加
     *   0x31=温度减
     * 
     * @return 调整后的温度
     */
    fun increaseACTemperature(): Int {
        Timber.tag(TAG).w("提高空调温度")
        try {
            // 使用Car API发送温度加命令
            carPropertyUtils.setIntProperty(ID_AC_TEMPERATURE, 0x1, 0x30)
            
            // 获取当前温度值
            val tempValue = carPropertyUtils.getFloatStatus(ID_AC_TEMPERATURE, 0x1).toInt()
            
            // 解析温度值
            currentAcTemperature = when (tempValue) {
                0x01 -> 17 // LO
                0x1F -> 33 // HI
                in 0x02..0x1E -> tempValue + 16 // 18~32℃
                else -> currentAcTemperature // 未知情况保持原值
            }
            
            Timber.tag(TAG).w("提高空调温度完成，当前温度值: $tempValue, 温度: $currentAcTemperature°C")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "提高空调温度失败")
            // 出错时仍使用本地变量模拟
            if (currentAcTemperature < maxTemperature) {
                currentAcTemperature++
            }
        }
        return currentAcTemperature
    }
    
    /**
     * 降低空调温度
     * 
     * ID: 0x15600503 (ID_AC_TEMPERATURE)
     * 区域: 0x1
     * 值类型: int
     * 值说明: 
     *   0x01=LO (17.5℃)
     *   0x02-0x1E=18~32℃
     *   0x1F=HI (32.5℃)
     *   0x30=温度加
     *   0x31=温度减
     *   
     * @return 调整后的温度
     */
    fun decreaseACTemperature(): Int {
        Timber.tag(TAG).w("降低空调温度")
        try {
            // 使用Car API发送温度减命令
            carPropertyUtils.setIntProperty(ID_AC_TEMPERATURE, 0x1, 0x31)
            
            // 获取当前温度值
            val tempValue = carPropertyUtils.getFloatStatus(ID_AC_TEMPERATURE, 0x1).toInt()
            
            // 解析温度值
            currentAcTemperature = when (tempValue) {
                0x01 -> 17 // LO
                0x1F -> 33 // HI
                in 0x02..0x1E -> tempValue + 16 // 18~32℃
                else -> currentAcTemperature // 未知情况保持原值
            }
            
            Timber.tag(TAG).w("降低空调温度完成，当前温度值: $tempValue, 温度: $currentAcTemperature°C")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "降低空调温度失败")
            // 出错时仍使用本地变量模拟
            if (currentAcTemperature > minTemperature) {
                currentAcTemperature--
            }
        }
        return currentAcTemperature
    }
    
    /**
     * 获取当前空调温度
     * 
     * @return 当前温度值（摄氏度）
     */
    fun getCurrentACTemperature(): Int {
        try {
            // 尝试从车辆获取实际温度值
            val tempValue = carPropertyUtils.getIntStatus(ID_AC_TEMPERATURE, 0x1)
            
            // 解析温度值
            currentAcTemperature = when (tempValue) {
                0x01 -> 17 // LO
                0x1F -> 33 // HI
                in 0x02..0x1E -> tempValue + 16 // 18~32℃
                else -> currentAcTemperature // 未知情况保持原值
            }
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "获取当前空调温度失败，使用缓存值: $currentAcTemperature")
            // 失败时使用当前缓存值
        }
        return currentAcTemperature
    }
    
    /**
     * 提高空调风量
     * 
     * ID: 0x25401908 (ID_AC_FAN_SPEED_SET)
     * 区域: 0xF
     * 值类型: int
     * 值说明:
     *   1-N=档位
     *   0xAA=风量减
     *   0xBB=风量加
     * 
     * @return 调整后的风扇速度
     */
    suspend fun increaseFanSpeed(): Int {
        Timber.tag(TAG).w("提高空调风量")
        try {
            // 使用Car API发送风量加命令
            carPropertyUtils.setIntProperty(ID_AC_FAN_SPEED_SET, 0xF, 0xBB)
            
            // 获取当前风量值
            val fanLevel = carPropertyUtils.getIntStatus(ID_AC_FAN_SPEED_GET, 0xF)
            
            // 使用实际风量值更新本地变量
            if (fanLevel in 1..maxFanSpeed) {
                currentFanSpeed = fanLevel
            }
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "提高空调风量 $currentFanSpeed"))
            
            Timber.tag(TAG).w("提高空调风量完成，当前风量: $currentFanSpeed")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "提高空调风量失败")
            // 出错时仍使用本地变量模拟
            if (currentFanSpeed < maxFanSpeed) {
                currentFanSpeed++
            }
        }
        return currentFanSpeed
    }
    
    /**
     * 降低空调风量
     * 
     * ID: 0x25401908 (ID_AC_FAN_SPEED_SET)
     * 区域: 0xF
     * 值类型: int
     * 值说明:
     *   1-N=档位
     *   0xAA=风量减
     *   0xBB=风量加
     * 
     * @return 调整后的空调风量
     */
    suspend fun decreaseFanSpeed(): Int {
        Timber.tag(TAG).w("降低空调风量")
        try {
            // 使用Car API发送风量减命令
            carPropertyUtils.setIntProperty(ID_AC_FAN_SPEED_SET, 0xF, 0xAA)
            
            // 获取当前风量值
            val fanLevel = carPropertyUtils.getIntStatus(ID_AC_FAN_SPEED_GET, 0xF)
            
            // 使用实际风量值更新本地变量
            if (fanLevel in 0..maxFanSpeed) {
                currentFanSpeed = fanLevel
            }
            deviceEventsFlow.emit(DeviceEvent.SetFunction("", "降低空调风量 $currentFanSpeed"))
            Timber.tag(TAG).w("降低空调风量完成，当前风量: $currentFanSpeed")
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "降低空调风量失败")
            // 出错时仍使用本地变量模拟
            if (currentFanSpeed > minFanSpeed) {
                currentFanSpeed--
            }
        }
        return currentFanSpeed
    }
    
    /**
     * 获取当空调风量
     * 
     * @return 当前风扇速度（1-7档）
     */
    fun getCurrentFanSpeed(): Int {
        try {
            // 尝试从车辆获取实际风量值
            val fanLevel = carPropertyUtils.getIntStatus(ID_AC_FAN_SPEED_GET, 0xF)
            
            // 更新风扇速度（如果值合理）
            if (fanLevel in 1..maxFanSpeed) {
                currentFanSpeed = fanLevel
            }
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "获取当前风扇速度失败，使用缓存值: $currentFanSpeed")
            // 失败时使用当前缓存值
        }
        return currentFanSpeed
    }
    
    /**
     * 切换内外循环状态
     */
    private fun toggleCirculation() {
        Timber.tag(TAG).w("切换内外循环状态")
        // TODO: 实现内外循环状态切换逻辑
    }
    
    /**
     * 切换座椅加热开关状态
     */
    private fun toggleSeatHeat() {
        Timber.tag(TAG).w("切换座椅加热开关状态")
        // TODO: 实现座椅加热开关状态切换逻辑
    }
    
    /**
     * 切换车窗开关状态
     */
    private fun toggleWindows() {
        Timber.tag(TAG).w("切换车窗开关状态")
        // TODO: 实现车窗开关状态切换逻辑
    }
    
    /**
     * 切换空调自动模式开关状态
     */
    private fun toggleAutoMode() {
        Timber.tag(TAG).w("切换空调自动模式开关状态")
        // TODO: 实现空调自动模式开关状态切换逻辑
    }
    
    /**
     * 循环切换空调温度模式（单区/双区）
     * 
     * ID: 0x15400505 (ID_AC_ZONE_TEMP)
     * 区域: 0xF
     * 值类型: int
     * 值说明:
     *   0x0=单区温度
     *   0x1=双区温度
     *   
     * @return 当前模式: true=双区, false=单区
     */
    fun toggleAcZoneMode(): Boolean {
        Timber.tag(TAG).w("切换空调温度模式（单区/双区）")
        try {
            // 获取当前模式
            val currentMode = carPropertyUtils.getIntStatus(ID_AC_ZONE_TEMP, 0xF)
            Timber.tag(TAG).w("当前温度模式: ${if (currentMode == 1) "双区" else "单区"}")
            
            // 切换模式：如果是单区则切换到双区，如果是双区则切换到单区
            val newMode = if (currentMode == 1) 0 else 1
            
            // 设置新模式
            carPropertyUtils.setIntProperty(ID_AC_ZONE_TEMP, 0xF, newMode)
            
            Timber.tag(TAG).w("设置温度模式为: ${if (newMode == 1) "双区" else "单区"}")
            return newMode == 1
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换空调温度模式失败")
            return false
        }
    }
    
    /**
     * 切换空调内外循环
     * 
     * ID: 0x15400502 (ID_AC_INNER_OUTER_CYCLE)
     * 区域: 0xF
     * 值类型: int
     * 值说明:
     *   0x1=内循环
     *   0x2=外循环
     *   
     * @return 当前循环模式: true=内循环, false=外循环
     */
    fun toggleAcAirCirculation(): Boolean {
        Timber.tag(TAG).w("切换空调内外循环")
        try {
            // 获取当前循环模式
            val currentMode = carPropertyUtils.getIntStatus(ID_AC_INNER_OUTER_CYCLE, 0xF)
            Timber.tag(TAG).w("当前循环模式: ${if (currentMode == 1) "内循环" else "外循环"}")
            
            // 切换模式：如果是内循环则切换到外循环，如果是外循环则切换到内循环
            val newMode = if (currentMode == 1) 2 else 1
            
            // 设置新模式
            carPropertyUtils.setIntProperty(ID_AC_INNER_OUTER_CYCLE, 0xF, newMode)
            
            Timber.tag(TAG).w("设置循环模式为: ${if (newMode == 1) "内循环" else "外循环"}")
            return newMode == 1
        } catch (e: Exception) {
            Timber.tag(TAG).e(e, "切换空调内外循环失败")
            return false
        }
    }
} 